We started out by designing the server that would facilitate communication between players and control the game from a centralized server. The code blocks below model the client-server communication protocol used to simulate the game. Left side runs on the centralized server, while the right side is running on each RasbperryPi.
class Game:
def __init__(self, pub_id):
# Shared Structures
self.pid = pub_id
self.ip = socket.gethostname()
self.sid = random.randint(1000, 6553)
self.proc = None
# Thread Variables
self.manager = Manager()
self.unassigned = self.manager.dict()
self.assignedA = self.manager.dict()
self.assignedB = self.manager.dict()
self.running = Value("i", 0)
def startListening(self):
while not self.proc:
self.proc = Process(target=listener, args=(self,))
self.proc.start()
def stopListening(self):
while self.proc.is_alive():
self.proc.terminate()
self.proc = None
def isListening(self):
if not self.running.value and self.proc:
return self.proc.is_alive()
return False
def startPlaying(self):
while not self.proc:
self.proc = Process(target=manager, args=(self,))
self.proc.start()
def stopPlaying(self):
while self.proc.is_alive():
self.proc.terminate()
self.proc = None
def isPlaying(self):
if self.running.value and self.proc:
return self.proc.is_alive()
return False
def notifyTeams(self, messege):
d = self.get_teams()
d["msg"] = messege
# pool = Pool(processes=4)
for team in [self.assignedA, self.assignedB]:
for k,v in team.items():
pool.apply(sendMsg, args=(v["ip"], self.sid, d,))
pool.close()
pool.join()
def notifyExtras(self, messege):
d = self.get_teams()
d["msg"] = messege
pool = Pool(processes=4)
for k,v in self.unassigned.items():
pool.apply(sendMsg, args=(v["ip"], self.sid, d,))
pool.close()
pool.join()
def notifyAll(self, messege):
d = self.get_teams()
d["msg"] = messege
pool = Pool(processes=4)
for team in [self.assignedA, self.assignedB, self.unassigned]:
for k,v in team.items():
pool.apply(sendMsg, args=(v["ip"], self.sid, d,))
pool.close()
pool.join()
def getTeamCounts(self):
pool = Pool(processes=4)
teams = [self.assignedA, self.assignedB]
counts = pool.map(counter, teams)
pool.close()
pool.join()
return counts
def whoWon(self):
counts = self.getTeamCounts()
if counts[0] > counts[1]: return 1
elif counts[1] > counts[0]: return 2
else: return 0
def override_teams(self, data):
pool = Pool(processes=3)
pool.apply(overrideDict, args=(self.assignedA, data["assignedA"],))
pool.apply(overrideDict, args=(self.assignedB, data["assignedB"],))
pool.apply(overrideDict, args=(self.unassigned, data["unassigned"],))
pool.close()
pool.join()
def get_teams(self):
return {"unassigned" : self.unassigned.values(),
"assignedA" : self.assignedA.values(),
"assignedB" : self.assignedB.values()}
def counter(sharedStruct):
count = 0
for k,v in sharedStruct.items():
if v["isAlive"]: count+=1
return count
############### HELPER FUNCTIONS ########################
# used to help up parallize some of the redundant tasks
#########################################################
def overrideDict(sharedStruct, newStruct):
old_keys = sharedStruct.keys()
used_keys = []
for each in newStruct:
used_keys.append(each[KEY])
sharedStruct[each[KEY]] = each
for old_k in old_keys:
if old_k not in used_keys:
del sharedStruct[old_k]
def sendMsg(player_ip, player_port, data):
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((player_ip, player_port))
s.send(str(data).encode())
s.recv(BUFFER_SIZE)
s.close()
except Exception as e:
print("Could NOT send MSG to", player_ip)
print(e)
def listener(game):
soc = socket.socket()
soc.bind(("", game.pid))
soc.listen(1)
while True:
# establish connection with client
conn, addr = soc.accept()
# data received from client
data = eval(conn.recv(BUFFER_SIZE).decode("UTF-8"))
# update shared structure
game.unassigned[data[KEY]]=data
# send recipt & close
conn.send(str(game.sid).encode())
conn.close()
soc.close()
def manager(game):
soc = socket.socket()
soc.bind(("", game.sid))
soc.listen(1)
while True:
# establish connection with client
conn, addr = soc.accept()
# data received from client
data = eval(conn.recv(BUFFER_SIZE).decode("UTF-8"))
# update shared structure
if data[KEY] in game.assignedA.keys():
game.assignedA[data[KEY]] = data
elif data[KEY] in game.assignedB.keys():
game.assignedB[data[KEY]] = data
else:
game.unassigned[data[KEY]] = data
counts = game.getTeamCounts()
if 0 in counts:
game.notifyTeams("stop")
else:
game.notifyTeams("update")
# send recipt & close // FIXME
conn.send("successfully updated".encode())
conn.close()
soc.close()
class Player:
def __init__(self, pub_id):
self.pid = pub_id
self.name = socket.gethostname()
try:
self.ip = subprocess.check_output(["hostname", "-I"])[:-2]
except:
self.ip = subprocess.check_output(["hostname"])[:-2]
self.manager = Manager()
self.unassigned = self.manager.dict()
self.assignedA = self.manager.dict()
self.assignedB = self.manager.dict()
self.running = Value("i", 0)
self.isAlive = 1
self.team = None
self.sid = None
self.proc = None
def joinRoom(self):
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((SERVER_IP, self.pid))
s.send(str({"ip": self.ip, "name" : self.name, "isAlive": self.isAlive}).encode())
self.sid = int(s.recv(BUFFER_SIZE).decode("UTF-8"))
s.close()
print("joined the game", self.pid)
except:
print("Could NOT establish a Handshake.")
def notifyDeath(self):
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((SERVER_IP, self.sid))
s.send(str({"ip": self.ip, "name" :self.name, "isAlive": self.isAlive}).encode())
s.recv(BUFFER_SIZE)
s.close()
except:
print("Could NOT send a death note")
def startListening(self):
while not self.proc:
self.proc = Process(target=listener, args=(self,))
self.proc.start()
def stopListening(self):
while self.proc.is_alive():
self.proc.terminate()
self.proc = None
def override_teams(self, data):
pool = Pool(processes=3)
pool.apply(overrideDict, args=(self.assignedA, data["assignedA"],))
pool.apply(overrideDict, args=(self.assignedB, data["assignedB"],))
pool.apply(overrideDict, args=(self.unassigned, data["unassigned"],))
def get_teams(self):
return {"unassigned" : self.unassigned.values(),
"assignedA" : self.assignedA.values(),
"assignedB" : self.assignedB.values()}
def overrideDict(sharedStruct, newStruct):
old_keys = sharedStruct.keys()
used_keys = []
for each in newStruct:
used_keys.append(each[KEY])
sharedStruct[each[KEY]] = each
for old_k in old_keys:
if old_k not in used_keys:
del sharedStruct[old_k]
############### HELPER FUNCTIONS ########################
# used to help up parallize some of the redundant tasks
#########################################################
def listener(player):
soc = socket.socket()
soc.bind(("", player.sid))
soc.listen(1)
print("listening to port ", player.sid)
while True:
# establish connection with client
conn, addr = soc.accept()
# data received from client
data = eval(conn.recv(BUFFER_SIZE).decode("UTF-8"))
# update teams in parallel
player.override_teams(data)
print(data)
# send recipt
conn.send("successfully updated")
# close the connection
conn.close()
# update the state of the game
# update the state of the game
if data["msg"] == "start":
player.running.value = 1
print("game started on port ", player.sid)
elif data["msg"] == "stop":
player.running.value = 0
print("game terminated on port ", player.sid)
break # exits the loop
soc.close()
print("closed port ", player.sid)
